home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 3: CDPD 3 / Almathera Ten on Ten - Disc 3: CDPD3.iso / scope / 051-075 / scopedisk55 / dirk2 / arg.c < prev    next >
C/C++ Source or Header  |  1995-03-18  |  6KB  |  171 lines
  1. /***************************************************************************
  2.     1/89
  3.  
  4.         DIRK v2.0 -- Tune workbench colors to system performance
  5.  
  6.         Copyright (C) 1989 by Daniel Elbaum
  7.  
  8.         This software is freely redistributable provided that:
  9.         the four files which comprise it (dirk, dirk.doc, dirk.h,
  10.         adjust.c, main.c, sys, window.c) remain intact; all
  11.         copyright notices contained in any of the aforementioned
  12.         files remain intact; and no fee beyond reasonable remuneration
  13.         for collation and distribution be charged for use and/or
  14.         distribution.
  15.  
  16. ***************************************************************************/
  17.  
  18.  
  19. #include "dirk.h"
  20.  
  21. getargs(v, f)
  22. char **v;
  23. t_gf *f;
  24. {
  25.     register out=0;
  26.  
  27.     f->gran  = 4;      /*  good when 4-5 processes are in background   */
  28.     f->dsmax = 12;     /*  takes some glare out of text                */
  29.     f->dsmin = 8;      /*  readable even at near-red                   */
  30.     f->dstog = 1;      /*  task watcher on by default                  */
  31.     f->bstog = 1;      /*  memory watcher on by default                */
  32.     f->intvl = 180;    /*  default delay is 3 seconds                  */
  33.     f->bd_r  = 2;      /*  increment for detail pen red                */
  34.     f->bd_g  = 2;      /*  increment for detail pen green              */
  35.     f->bd_b  = 0;      /*  increment for detail pen blue               */
  36.  
  37.     f->hb_r  = 14;      /*  go from blue 14 to red 14 as memory fills   */
  38.     f->hb_g  = 0;
  39.     f->hb_b  = 0;
  40.     f->lb_r  = 0;
  41.     f->lb_g  = 0;
  42.     f->lb_b  = 14;
  43.  
  44.     while (*v){
  45.         if (**v=='-') {
  46.             if (!(*v)[1]) return(usage());
  47.             while (*++*v){
  48.                 switch(**v){
  49.                     case 'g': f->gran=atoi(++*v); ++out; break;
  50.                     case 'h': f->dsmax=atoi(++*v); ++out; break;
  51.                     case 'l': f->dsmin=atoi(++*v); ++out; break;
  52.                     case 'i': f->intvl=atoi(++*v); ++out; break;
  53.                     case 't': f->bstog=0; break;
  54.                     case 'm': f->dstog=0; break;
  55.                     case 'd':
  56.                         switch(*++*v){
  57.                             case 'r': f->bd_r=atoi(++*v); ++out; break;
  58.                             case 'g': f->bd_g=atoi(++*v); ++out; break;
  59.                             case 'b': f->bd_b=atoi(++*v); ++out; break;
  60.                             default: return(usage());
  61.                         }
  62.                         break;
  63.                     case 'e':
  64.                         switch(*++*v){
  65.                             case 'r': f->lb_r=atoi(++*v); ++out; break;
  66.                             case 'g': f->lb_g=atoi(++*v); ++out; break;
  67.                             case 'b': f->lb_b=atoi(++*v); ++out; break;
  68.                             default: return(usage());
  69.                         }
  70.                         break;
  71.                     case 'f':
  72.                         switch(*++*v){
  73.                             case 'r': f->hb_r=atoi(++*v); ++out; break;
  74.                             case 'g': f->hb_g=atoi(++*v); ++out; break;
  75.                             case 'b': f->hb_b=atoi(++*v); ++out; break;
  76.                             default: return(usage());
  77.                         }
  78.                         break;
  79.                     default: return(usage());
  80.                 }                               /* switch (**v) */
  81.                 if (out) {++v; break;}
  82.             }                               /* while (*++*v)  */
  83.             if (!out) ++v;
  84.             else out=0;
  85.         }                               /* else if (**v=='+')   */
  86.         else {
  87.             return(usage());
  88.         }
  89.     }                               /* while (*v)   */
  90.     limit(f);
  91.     if (f->gran==0) f->gran=1;  /* special case for x/gran  */
  92.     return(0);
  93. }
  94.  
  95. #define LFIX(x, l)   if (x<l) x=l
  96. #define HFIX(x, h)   if (x>h) x=h
  97.  
  98. /*
  99.     Make sure all members of *f are in bounds.
  100. */
  101.  
  102. limit(f)
  103. t_gf *f;
  104. {
  105.     int tmp;
  106.     int maxint=(1<<sizeof(maxint))-1;
  107.  
  108.  
  109.     LFIX(f->gran, 0);
  110.     HFIX(f->gran, maxint);
  111.     LFIX(f->dsmax, 0);
  112.     HFIX(f->dsmax, CMAX);
  113.     LFIX(f->dsmin, 0);
  114.     HFIX(f->dsmin, CMAX);
  115.     LFIX(f->intvl, 0);
  116.     HFIX(f->intvl, maxint);
  117.  
  118.     LFIX(f->bd_r, 0);
  119.     HFIX(f->bd_r, CMAX);
  120.     LFIX(f->bd_g, 0);
  121.     HFIX(f->bd_g, CMAX);
  122.     LFIX(f->bd_b, 0);
  123.     HFIX(f->bd_b, CMAX);
  124.  
  125.     LFIX(f->lb_r, 0);
  126.     HFIX(f->lb_r, CMAX);
  127.     LFIX(f->lb_g, 0);
  128.     HFIX(f->lb_g, CMAX);
  129.     LFIX(f->lb_b, 0);
  130.     HFIX(f->lb_b, CMAX);
  131.  
  132.     LFIX(f->hb_r, 0);
  133.     HFIX(f->hb_r, CMAX);
  134.     LFIX(f->hb_g, 0);
  135.     HFIX(f->hb_g, CMAX);
  136.     LFIX(f->hb_b, 0);
  137.     HFIX(f->hb_b, CMAX);
  138.  
  139.     /* db may be negative   */
  140.  
  141.     f->db_r = f->hb_r-f->lb_r;
  142.     f->db_g = f->hb_g-f->lb_g;
  143.     f->db_b = f->hb_b-f->lb_b;
  144. }
  145.  
  146. usage()
  147. {
  148.     printf("Dirk v2.0 copyright (c) 1989 Daniel Elbaum\n");
  149.     printf("\nUsage: dirk [-t|m] [-gN] [-hN] [-lN] [-iN]]...\n");
  150.     printf("t\ttrack tasks only\n");
  151.     printf("m\ttrack memory only\n");
  152.     printf("g   (4)\tgranularity of task mapping (small for few tasks)\n");
  153.     printf("h  (12)\tmaximum detail saturation\n");
  154.     printf("l   (8)\tminimum detail saturation\n");
  155.     printf("i (180)\tinterval in ticks (60 or 50 per second)\n");
  156.     printf("\n...");
  157. printf("\t[-drN] [-dgN] [-dbN] [-erN] [-egN] [-ebN] [-frN] [-fgN] [-fbN]\n");
  158.     printf("dr  (2)\tamount by which to redden the detail pen\n");
  159.     printf("dg  (2)\tamount by which to greeen the detail pen\n");
  160.     printf("db  (0)\tamount by which to bluen the detail pen\n");
  161.     printf("er  (0)\tamount of red for empty memory\n");
  162.     printf("eg  (0)\tamount of green for empty memory\n");
  163.     printf("eb (14)\tamount of blue for empty memory\n");
  164.     printf("fr (14)\tamount of red for full memory\n");
  165.     printf("fg  (0)\tamount of green for full memory\n");
  166.     printf("fb  (0)\tamount by blue for full memory\n");
  167.     return(-1);
  168. }
  169.  
  170.  
  171.